+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
+Thu Sep 3 04:22:20 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkmenushell.c (gtk_real_menu_shell_move_current):
+ GTK_MENU_DIR_CHILD: check for the existance of
+ menu_shell->active_menu_item before accessing its child.
+ GTK_MENU_DIR_PREV:
+ GTK_MENU_DIR_NEXT: if we haven't had an active item and still
+ don't, make a default selection.
+
+Wed Sep 2 00:28:58 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkwidget.c (gtk_widget_propagate_state): iterate
+ the children with _forall for sensitivity changes and with
+ _foreach on pure state changes. this fixes a lot of the
+ old inclusions of internal widgets into _foreach calls.
+
+ * gtk/gtktree.c: removed gtk_tree_foreach, let gtk_tree_forall
+ do the work. don't walk the subtrees of first level children.
+
+ * gtk/gtktreeitem.c: provide a _forall implementation,
+ which walks the subtrees as well for include_internals.
+
+ * gtk/gtkmenuitem.c: provide a _forall implementation, which walks
+ the submenus as well for include_internals.
+
+ * gtk/gtkscrolledwindow.c: removed gtk_scrolled_window_foreach and
+ implemented gtk_scrolled_window_forall, which will iterate over
+ the viewport and the scrollbars for gtk_container_forall or
+ iterate over the viewports children for gtk_container_foreach.
+
+ * gtk/gtktoolbar.c:
+ * gtk/gtktable.c:
+ * gtk/gtkpaned.c:
+ * gtk/gtkpacker.c:
+ * gtk/gtkmenushell.c:
+ * gtk/gtklist.c:
+ * gtk/gtkfixed.c:
+ * gtk/gtkclist.c:
+ * gtk/gtkbox.c:
+ * gtk/gtkbin.c:
+ * gtk/gtknotebook.c:
+ removed the old gtk_*_foreach functions and provided gtk_*_forall.
+
+ * gtk/gtknotebook.c:
+ (gtk_notebook_real_switch_page): expose tabs.
+ (gtk_notebook_page_num): new function to return the page number
+ of a distinct child.
+ (gtk_notebook_focus): minor fixups. foxus handling is still screwed
+ under some circumstances.
+
+ * gtk/gtktreeitem.c:
+ (gtk_real_tree_item_select):
+ (gtk_real_tree_item_deselect): major fixes.
+ some general fixups wrt queue_redraw, and tree items not being
+ NO_WINDOW widgets.
+
+ * gtk/gtklistitem.c:
+ (gtk_real_list_item_select):
+ (gtk_real_list_item_deselect):
+ (gtk_real_list_item_toggle):
+ removed unneccessary queue_redraw calls.
+
+Wed Aug 30 09:42:07 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkoptionmenu.c: allow optionmenus to have the focus and
+ automatically popup the menu on space bar.
+
+Wed Aug 26 06:40:34 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtkcontainer.h:
+ * gtk/gtkcontainer.c: implemented gtk_container_forall() (as a class
+ method), which acts similar to gtk_container_foreach(), but iterates
+ over internal children. the GtkContainer::foreach signal vanished in
+ favour of a new class method ->forall() that optionally includes
+ internal widgets.
+
+ * gtk/gtkclist.c (gtk_clist_init): provide no _foreach implementation
+ but a _forall implementation, since all child widgets we have are
+ internal ones.
+ (column_button_create): set the parent window prior
+ to gtk_widget_set_parent().
+
+ * gtk/gtkwidget.c:
+ exchanged all calls to gtk_container_foreach() with
+ gtk_container_forall().
+
+ * gtk/gtkwidget.h:
+ * gtk/gtkwidget.c: added the GTK_COMPOSITE_CHILD, exported through
+ the GtkWidget::composite_child argument. to have a widget created
+ with the flag initially, two new functions got added to wrap a widgets
+ creation:
+ gtk_widget_push_composite_flag() and gtk_widget_pop_composite_flag().
+
+Wed Aug 25 23:37:39 1998 Tim Janik <timj@gtk.org>
+
+ * gtk/gtktooltips.h:
+ * gtk/gtktooltips.c: exported gtk_tooltips_create_window() as
+ gtk_tooltips_force_window(), so tooltips->tip_window can be accessed
+ prior to the first tip being set.
+ don't put an extra reference on the window, since it is a toplevel,
+ it wont get destroyed from anywhere else.
+
+ * overall macro and GtkType fixups.
+
1998-09-02 Federico Mena Quintero <federico@nuclecu.unam.mx>
* gtk/gtkcolorsel.c: Replaced "foo == TRUE" and "foo == FALSE"
(has-default GTK_HAS_DEFAULT)
(has-grab GTK_HAS_GRAB)
(rc-style GTK_RC_STYLE)
+ (composite-child GTK_COMPOSITE_CHILD)
(basic GTK_BASIC))
; enumerations from "../gdk/gdkprivate.h"
GtkWidget *widget);
static void gtk_bin_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_bin_foreach (GtkContainer *container,
+static void gtk_bin_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static GtkType gtk_bin_child_type (GtkContainer*container);
container_class->add = gtk_bin_add;
container_class->remove = gtk_bin_remove;
- container_class->foreach = gtk_bin_foreach;
+ container_class->forall = gtk_bin_forall;
container_class->child_type = gtk_bin_child_type;
}
}
static void
-gtk_bin_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_bin_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkBin *bin;
GtkWidget *widget);
static void gtk_box_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_box_foreach (GtkContainer *container,
+static void gtk_box_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_box_set_child_arg (GtkContainer *container,
container_class->add = gtk_box_add;
container_class->remove = gtk_box_remove;
- container_class->foreach = gtk_box_foreach;
+ container_class->forall = gtk_box_forall;
container_class->child_type = gtk_box_child_type;
container_class->set_child_arg = gtk_box_set_child_arg;
container_class->get_child_arg = gtk_box_get_child_arg;
}
static void
-gtk_box_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_box_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkBox *box;
GtkBoxChild *child;
gint * column);
/* GtkContainer Methods */
-static void gtk_clist_foreach (GtkContainer * container,
- GtkCallback callback,
- gpointer callback_data);
+static void gtk_clist_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
/* Drawing */
static void draw_row (GtkCList * clist,
/* container_class->add = NULL; use the default GtkContainerClass warning */
/* container_class->remove = NULL; use the default GtkContainerClass warning */
- container_class->foreach = gtk_clist_foreach;
+ container_class->forall = gtk_clist_forall;
container_class->focus = gtk_clist_focus;
container_class->set_focus_child = gtk_clist_set_focus_child;
/*
* GTKCONTAINER
- * gtk_clist_foreach
+ * gtk_clist_forall
*/
static void
-gtk_clist_foreach (GtkContainer * container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_clist_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
- gint i;
GtkCList *clist;
g_return_if_fail (container != NULL);
g_return_if_fail (callback != NULL);
clist = GTK_CLIST (container);
-
- /* callback for the column buttons */
- for (i = 0; i < clist->columns; i++)
- if (clist->column[i].button)
- (*callback) (clist->column[i].button, callback_data);
-
- /* callbacks for the scrollbars */
- if (clist->vscrollbar)
- (*callback) (clist->vscrollbar, callback_data);
- if (clist->hscrollbar)
- (*callback) (clist->hscrollbar, callback_data);
+
+ if (include_internals)
+ {
+ guint i;
+
+ /* callback for the column buttons */
+ for (i = 0; i < clist->columns; i++)
+ if (clist->column[i].button)
+ (*callback) (clist->column[i].button, callback_data);
+
+ /* callbacks for the scrollbars */
+ if (clist->vscrollbar)
+ (*callback) (clist->vscrollbar, callback_data);
+ if (clist->hscrollbar)
+ (*callback) (clist->hscrollbar, callback_data);
+ }
}
/*
GtkWidget *button;
button = clist->column[column].button = gtk_button_new ();
- gtk_widget_set_parent (button, GTK_WIDGET (clist));
if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
gtk_widget_set_parent_window (clist->column[column].button, clist->title_window);
+ gtk_widget_set_parent (button, GTK_WIDGET (clist));
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) column_button_clicked,
ADD,
REMOVE,
CHECK_RESIZE,
- FOREACH,
FOCUS,
SET_FOCUS_CHILD,
LAST_SIGNAL
GTK_SIGNAL_OFFSET (GtkContainerClass, check_resize),
gtk_marshal_NONE__NONE,
GTK_TYPE_NONE, 0);
- container_signals[FOREACH] =
- gtk_signal_new ("foreach",
- GTK_RUN_FIRST,
- object_class->type,
- GTK_SIGNAL_OFFSET (GtkContainerClass, foreach),
- gtk_marshal_NONE__C_CALLBACK,
- GTK_TYPE_NONE, 1,
- GTK_TYPE_C_CALLBACK);
container_signals[FOCUS] =
gtk_signal_new ("focus",
GTK_RUN_LAST,
object_class->get_arg = gtk_container_get_arg;
object_class->set_arg = gtk_container_set_arg;
object_class->destroy = gtk_container_destroy;
-
- /* Other container classes should overwrite show_all and hide_all,
- * for the purpose of showing internal children also, which are not
- * accessable through gtk_container_foreach.
- */
+
widget_class->show_all = gtk_container_show_all;
widget_class->hide_all = gtk_container_hide_all;
-
+
class->add = gtk_container_add_unimplemented;
class->remove = gtk_container_remove_unimplemented;
class->check_resize = gtk_container_real_check_resize;
- class->foreach = NULL;
+ class->forall = NULL;
class->focus = gtk_container_real_focus;
class->set_focus_child = gtk_container_real_set_focus_child;
class->child_type = NULL;
}
gtk_container_clear_resize_widgets (container);
- gtk_container_foreach (container,
- (GtkCallback) gtk_widget_destroy, NULL);
+ gtk_container_foreach (container, (GtkCallback) gtk_widget_destroy, NULL);
if (GTK_OBJECT_CLASS (parent_class)->destroy)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
g_slist_free (resize_containers);
}
+void
+gtk_container_forall (GtkContainer *container,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GtkContainerClass *class;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (container));
+ g_return_if_fail (callback != NULL);
+
+ class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+
+ if (class->forall)
+ class->forall (container, TRUE, callback, callback_data);
+}
+
void
gtk_container_foreach (GtkContainer *container,
GtkCallback callback,
gpointer callback_data)
{
+ GtkContainerClass *class;
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (callback != NULL);
- gtk_signal_emit (GTK_OBJECT (container),
- container_signals[FOREACH],
- callback, callback_data);
+ class = GTK_CONTAINER_CLASS (GTK_OBJECT (container)->klass);
+
+ if (class->forall)
+ class->forall (container, FALSE, callback, callback_data);
}
typedef struct _GtkForeachData GtkForeachData;
g_return_val_if_fail (container != NULL, FALSE);
g_return_val_if_fail (GTK_IS_CONTAINER (container), FALSE);
- /* Fail if the container is insensitive
+ /* Fail if the container is inappropriate for focus movement
*/
- if (!GTK_WIDGET_SENSITIVE (container))
+ if (!GTK_WIDGET_DRAWABLE (container) ||
+ !GTK_WIDGET_SENSITIVE (container))
return FALSE;
return_val = FALSE;
{
/* Get a list of the containers children
*/
- children = gtk_container_children (container);
+ children = NULL;
+ gtk_container_forall (container,
+ gtk_container_children_callback,
+ &children);
+ children = g_list_reverse (children);
+ /* children = gtk_container_children (container); */
if (children)
{
- /* Remove any children which are insensitive
+ /* Remove any children which are inappropriate for focus movement
*/
tmp_list = children;
while (tmp_list)
{
- if (!GTK_WIDGET_SENSITIVE (tmp_list->data))
+ if (GTK_WIDGET_SENSITIVE (tmp_list->data) &&
+ GTK_WIDGET_DRAWABLE (tmp_list->data) &&
+ (GTK_IS_CONTAINER (tmp_list->data) || GTK_WIDGET_CAN_FOCUS (tmp_list->data)))
+ tmp_list = tmp_list->next;
+ else
{
tmp_list2 = tmp_list;
tmp_list = tmp_list->next;
-
+
children = g_list_remove_link (children, tmp_list2);
g_list_free_1 (tmp_list2);
}
- else
- tmp_list = tmp_list->next;
}
switch (direction)
{
focus_child = NULL;
- if (GTK_WIDGET_VISIBLE (child) &&
+ if (GTK_WIDGET_DRAWABLE (child) &&
GTK_IS_CONTAINER (child) &&
!GTK_WIDGET_HAS_FOCUS (child))
if (gtk_container_focus (GTK_CONTAINER (child), direction))
return TRUE;
}
}
- else if (GTK_WIDGET_VISIBLE (child))
+ else if (GTK_WIDGET_DRAWABLE (child))
{
if (GTK_IS_CONTAINER (child))
{
*children = g_list_prepend (*children, widget);
}
-static void
-gtk_container_show_all (GtkWidget *widget)
-{
- GtkContainer *container;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_CONTAINER (widget));
- container = GTK_CONTAINER (widget);
-
- /* First show children, then self.
- This makes sure that toplevel windows get shown as last widget.
- Otherwise the user would see the widgets get
- visible one after another.
- */
- gtk_container_foreach (container, (GtkCallback) gtk_widget_show_all, NULL);
- gtk_widget_show (widget);
-}
-
-
-static void
-gtk_container_hide_all (GtkWidget *widget)
-{
- GtkContainer *container;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_CONTAINER (widget));
- container = GTK_CONTAINER (widget);
-
- /* First hide self, then children.
- This is the reverse order of gtk_container_show_all.
- */
- gtk_widget_hide (widget);
- gtk_container_foreach (container, (GtkCallback) gtk_widget_hide_all, NULL);
-}
-
void
gtk_container_set_focus_vadjustment (GtkContainer *container,
GtkAdjustment *adjustment)
adjustment,
(GtkDestroyNotify) gtk_object_unref);
}
+
+
+static void
+gtk_container_show_all (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (widget));
+
+ gtk_container_foreach (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_show_all,
+ NULL);
+ gtk_widget_show (widget);
+}
+
+static void
+gtk_container_hide_all (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_CONTAINER (widget));
+
+ gtk_widget_hide (widget);
+ gtk_container_foreach (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_hide_all,
+ NULL);
+}
void (* remove) (GtkContainer *container,
GtkWidget *widget);
void (* check_resize) (GtkContainer *container);
- void (* foreach) (GtkContainer *container,
+ void (* forall) (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callbabck_data);
gint (* focus) (GtkContainer *container,
gchar* gtk_container_child_arg_get_info (GtkType object_type,
const gchar *arg_name,
GtkArgInfo **info_p);
+void gtk_container_forall (GtkContainer *container,
+ GtkCallback callback,
+ gpointer callback_data);
/* Deprecated methods */
GtkWidget *widget);
static void gtk_fixed_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_fixed_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data);
+static void gtk_fixed_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
static GtkType gtk_fixed_child_type (GtkContainer *container);
static GtkContainerClass *parent_class = NULL;
-guint
+GtkType
gtk_fixed_get_type (void)
{
- static guint fixed_type = 0;
+ static GtkType fixed_type = 0;
if (!fixed_type)
{
(GtkClassInitFunc) NULL,
};
- fixed_type = gtk_type_unique (gtk_container_get_type (), &fixed_info);
+ fixed_type = gtk_type_unique (GTK_TYPE_CONTAINER, &fixed_info);
}
return fixed_type;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
widget_class->map = gtk_fixed_map;
widget_class->unmap = gtk_fixed_unmap;
container_class->add = gtk_fixed_add;
container_class->remove = gtk_fixed_remove;
- container_class->foreach = gtk_fixed_foreach;
+ container_class->forall = gtk_fixed_forall;
container_class->child_type = gtk_fixed_child_type;
}
{
GtkFixed *fixed;
- fixed = gtk_type_new (gtk_fixed_get_type ());
+ fixed = gtk_type_new (GTK_TYPE_FIXED);
return GTK_WIDGET (fixed);
}
}
static void
-gtk_fixed_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_fixed_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkFixed *fixed;
GtkFixedChild *child;
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_FIXED(obj) GTK_CHECK_CAST (obj, gtk_fixed_get_type (), GtkFixed)
-#define GTK_FIXED_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_fixed_get_type (), GtkFixedClass)
-#define GTK_IS_FIXED(obj) GTK_CHECK_TYPE (obj, gtk_fixed_get_type ())
+#define GTK_TYPE_FIXED (gtk_fixed_get_type ())
+#define GTK_FIXED(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_FIXED, GtkFixed))
+#define GTK_FIXED_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_FIXED, GtkFixedClass))
+#define GTK_IS_FIXED(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_FIXED))
+#define GTK_IS_FIXED_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_FIXED))
typedef struct _GtkFixed GtkFixed;
};
-guint gtk_fixed_get_type (void);
+GtkType gtk_fixed_get_type (void);
GtkWidget* gtk_fixed_new (void);
void gtk_fixed_put (GtkFixed *fixed,
GtkWidget *widget,
static guint item_signals[LAST_SIGNAL] = { 0 };
-guint
+GtkType
gtk_item_get_type (void)
{
- static guint item_type = 0;
+ static GtkType item_type = 0;
if (!item_type)
{
(GtkClassInitFunc) NULL,
};
- item_type = gtk_type_unique (gtk_bin_get_type (), &item_info);
+ item_type = gtk_type_unique (GTK_TYPE_BIN, &item_info);
}
return item_type;
g_return_if_fail (GTK_IS_ITEM (widget));
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+
gdk_window_show (widget->window);
bin = GTK_BIN (widget);
g_return_if_fail (GTK_IS_ITEM (widget));
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+
gdk_window_hide (widget->window);
}
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_ITEM(obj) GTK_CHECK_CAST (obj, gtk_item_get_type (), GtkItem)
-#define GTK_ITEM_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_item_get_type (), GtkItemClass)
-#define GTK_IS_ITEM(obj) GTK_CHECK_TYPE (obj, gtk_item_get_type ())
+#define GTK_TYPE_ITEM (gtk_item_get_type ())
+#define GTK_ITEM(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_ITEM, GtkItem))
+#define GTK_ITEM_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_ITEM, GtkItemClass))
+#define GTK_IS_ITEM(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_ITEM))
+#define GTK_IS_ITEM_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_ITEM))
typedef struct _GtkItem GtkItem;
};
-guint gtk_item_get_type (void);
-void gtk_item_select (GtkItem *item);
-void gtk_item_deselect (GtkItem *item);
-void gtk_item_toggle (GtkItem *item);
+GtkType gtk_item_get_type (void);
+void gtk_item_select (GtkItem *item);
+void gtk_item_deselect (GtkItem *item);
+void gtk_item_toggle (GtkItem *item);
#ifdef __cplusplus
GtkWidget *widget);
static void gtk_list_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_list_foreach (GtkContainer *container,
+static void gtk_list_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
GtkType
gtk_list_get_type (void)
{
- static guint list_type = 0;
+ static GtkType list_type = 0;
if (!list_type)
{
(GtkClassInitFunc) NULL,
};
- list_type = gtk_type_unique (gtk_container_get_type (), &list_info);
+ list_type = gtk_type_unique (GTK_TYPE_CONTAINER, &list_info);
}
return list_type;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
- parent_class = gtk_type_class (gtk_container_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
vadjustment_key_id = g_quark_from_static_string (vadjustment_key);
hadjustment_key_id = g_quark_from_static_string (hadjustment_key);
container_class->add = gtk_list_add;
container_class->remove = gtk_list_remove;
- container_class->foreach = gtk_list_foreach;
+ container_class->forall = gtk_list_forall;
container_class->child_type = gtk_list_child_type;
container_class->set_focus_child = gtk_list_set_focus_child;
container_class->focus = gtk_list_focus;
GtkWidget*
gtk_list_new (void)
{
- return GTK_WIDGET (gtk_type_new (gtk_list_get_type ()));
+ return GTK_WIDGET (gtk_type_new (GTK_TYPE_LIST));
}
static void
}
static void
-gtk_list_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_list_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkList *list;
GtkWidget *child;
g_return_if_fail (GTK_IS_LIST_ITEM (item));
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
- gtk_widget_queue_draw (GTK_WIDGET (item));
}
static void
return;
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_NORMAL);
- gtk_widget_queue_draw (GTK_WIDGET (item));
}
static void
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_NORMAL);
else
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
- gtk_widget_queue_draw (GTK_WIDGET (item));
}
}
static gint gtk_menu_motion_notify (GtkWidget *widget,
GdkEventMotion *event);
static void gtk_menu_deactivate (GtkMenuShell *menu_shell);
-static void gtk_menu_show_all (GtkWidget *widget);
-static void gtk_menu_hide_all (GtkWidget *widget);
+static void gtk_menu_show_all (GtkWidget *widget);
+static void gtk_menu_hide_all (GtkWidget *widget);
static void gtk_menu_position (GtkMenu *menu);
static void gtk_menu_reparent (GtkMenu *menu,
GtkWidget *new_parent,
widget_class->key_press_event = gtk_menu_key_press;
widget_class->motion_notify_event = gtk_menu_motion_notify;
widget_class->show_all = gtk_menu_show_all;
- widget_class->hide_all = gtk_menu_hide_all;
+ widget_class->hide_all = gtk_menu_hide_all;
menu_shell_class->submenu_placement = GTK_LEFT_RIGHT;
menu_shell_class->deactivate = gtk_menu_deactivate;
}
-static void
-gtk_menu_show_all (GtkWidget *widget)
-{
- GtkContainer *container;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MENU (widget));
- container = GTK_CONTAINER (widget);
-
- /* Show children, but not self. */
- gtk_container_foreach (container, (GtkCallback) gtk_widget_show_all, NULL);
-}
-
-
-static void
-gtk_menu_hide_all (GtkWidget *widget)
-{
- GtkContainer *container;
-
- g_return_if_fail (widget != NULL);
- g_return_if_fail (GTK_IS_MENU (widget));
- container = GTK_CONTAINER (widget);
-
- /* Hide children, but not self. */
- gtk_container_foreach (container, (GtkCallback) gtk_widget_hide_all, NULL);
-}
-
static void
gtk_menu_position (GtkMenu *menu)
{
{
GtkObject *object = GTK_OBJECT (menu);
GtkWidget *widget = GTK_WIDGET (menu);
-
gboolean was_floating = GTK_OBJECT_FLOATING (object);
+
gtk_object_ref (object);
gtk_object_sink (object);
gtk_object_unref (object);
}
+static void
+gtk_menu_show_all (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_MENU (widget));
+ /* Show children, but not self. */
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
+}
+static void
+gtk_menu_hide_all (GtkWidget *widget)
+{
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_MENU (widget));
+ /* Hide children, but not self. */
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
+}
gpointer user_data);
static void gtk_menu_item_show_all (GtkWidget *widget);
static void gtk_menu_item_hide_all (GtkWidget *widget);
+static void gtk_menu_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
static GtkItemClass *parent_class;
static guint menu_item_signals[LAST_SIGNAL] = { 0 };
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
GtkItemClass *item_class;
object_class = (GtkObjectClass*) klass;
widget_class = (GtkWidgetClass*) klass;
+ container_class = (GtkContainerClass*) klass;
item_class = (GtkItemClass*) klass;
parent_class = gtk_type_class (gtk_item_get_type ());
widget_class->draw = gtk_menu_item_draw;
widget_class->expose_event = gtk_menu_item_expose;
widget_class->show_all = gtk_menu_item_show_all;
- widget_class->hide_all = gtk_menu_item_hide_all;
+ widget_class->hide_all = gtk_menu_item_hide_all;
+
+ container_class->forall = gtk_menu_item_forall;
item_class->select = gtk_real_menu_item_select;
item_class->deselect = gtk_real_menu_item_deselect;
menuitem->right_justify = 1;
}
+
static void
gtk_menu_item_show_all (GtkWidget *widget)
{
- GtkContainer *container;
- GtkMenuItem *menu_item;
+ GtkMenuItem *menu_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
- container = GTK_CONTAINER (widget);
+
menu_item = GTK_MENU_ITEM (widget);
- /* Show children, traverse to submenu, show self. */
- gtk_container_foreach (container, (GtkCallback) gtk_widget_show_all, NULL);
+ /* show children including submenu */
if (menu_item->submenu)
gtk_widget_show_all (menu_item->submenu);
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_show_all, NULL);
+
gtk_widget_show (widget);
}
-
static void
gtk_menu_item_hide_all (GtkWidget *widget)
{
- GtkContainer *container;
- GtkMenuItem *menu_item;
+ GtkMenuItem *menu_item;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_ITEM (widget));
- container = GTK_CONTAINER (widget);
- menu_item = GTK_MENU_ITEM (widget);
- /* Reverse order of gtk_menu_item_show_all */
gtk_widget_hide (widget);
+
+ menu_item = GTK_MENU_ITEM (widget);
+
+ /* hide children including submenu */
+ gtk_container_foreach (GTK_CONTAINER (widget), (GtkCallback) gtk_widget_hide_all, NULL);
if (menu_item->submenu)
gtk_widget_hide_all (menu_item->submenu);
- gtk_container_foreach (container, (GtkCallback) gtk_widget_hide_all, NULL);
+}
+
+static void
+gtk_menu_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GtkBin *bin;
+ GtkMenuItem *menu_item;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_MENU_ITEM (container));
+ g_return_if_fail (callback != NULL);
+
+ bin = GTK_BIN (container);
+ menu_item = GTK_MENU_ITEM (container);
+
+ if (bin->child)
+ (* callback) (bin->child, callback_data);
+ if (include_internals && menu_item->submenu)
+ (* callback) (menu_item->submenu, callback_data);
}
GtkWidget *widget);
static void gtk_menu_shell_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_menu_shell_foreach (GtkContainer *container,
+static void gtk_menu_shell_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_real_menu_shell_deactivate (GtkMenuShell *menu_shell);
container_class->add = gtk_menu_shell_add;
container_class->remove = gtk_menu_shell_remove;
- container_class->foreach = gtk_menu_shell_foreach;
+ container_class->forall = gtk_menu_shell_forall;
container_class->child_type = gtk_menu_shell_child_type;
klass->submenu_placement = GTK_TOP_BOTTOM;
}
static void
-gtk_menu_shell_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_menu_shell_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkMenuShell *menu_shell;
GtkWidget *child;
GtkMenuDirectionType direction)
{
GtkMenuShell *parent_menu_shell = NULL;
+ gboolean had_selection;
+
+ had_selection = menu_shell->active_menu_item != NULL;
if (menu_shell->parent_menu_shell)
parent_menu_shell = GTK_MENU_SHELL (menu_shell->parent_menu_shell);
break;
case GTK_MENU_DIR_CHILD:
- if (GTK_BIN (menu_shell->active_menu_item)->child &&
+ if (menu_shell->active_menu_item &&
+ GTK_BIN (menu_shell->active_menu_item)->child &&
GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu)
{
menu_shell = GTK_MENU_SHELL (GTK_MENU_ITEM (menu_shell->active_menu_item)->submenu);
gtk_menu_shell_move_selected (parent_menu_shell, 1);
}
break;
-
+
case GTK_MENU_DIR_PREV:
gtk_menu_shell_move_selected (menu_shell, -1);
+ if (!had_selection &&
+ !menu_shell->active_menu_item &&
+ menu_shell->children)
+ gtk_menu_shell_select_item (menu_shell, g_list_last (menu_shell->children)->data);
break;
case GTK_MENU_DIR_NEXT:
gtk_menu_shell_move_selected (menu_shell, 1);
+ if (!had_selection &&
+ !menu_shell->active_menu_item &&
+ menu_shell->children)
+ gtk_menu_shell_select_item (menu_shell, menu_shell->children->data);
break;
}
+
}
static void
static void gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list,
guint page_num);
-static void gtk_notebook_foreach (GtkContainer *container,
+static void gtk_notebook_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_notebook_switch_page (GtkNotebook *notebook,
static void gtk_notebook_expose_tabs (GtkNotebook *notebook);
static void gtk_notebook_switch_focus_tab (GtkNotebook *notebook,
GList *new_child);
-static void gtk_real_notebook_switch_page (GtkNotebook *notebook,
+static void gtk_notebook_real_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
guint page_num);
static void gtk_notebook_menu_switch_page (GtkWidget *widget,
container_class->add = gtk_notebook_add;
container_class->remove = gtk_notebook_remove;
- container_class->foreach = gtk_notebook_foreach;
+ container_class->forall = gtk_notebook_forall;
container_class->focus = gtk_notebook_focus;
container_class->set_focus_child = gtk_notebook_set_focus_child;
container_class->get_child_arg = gtk_notebook_get_child_arg;
container_class->set_child_arg = gtk_notebook_set_child_arg;
container_class->child_type = gtk_notebook_child_type;
- class->switch_page = gtk_real_notebook_switch_page;
+ class->switch_page = gtk_notebook_real_switch_page;
}
static void
}
}
+gint
+gtk_notebook_page_num (GtkNotebook *notebook,
+ GtkWidget *child)
+{
+ GList *children;
+ gint num;
+
+ g_return_val_if_fail (notebook != NULL, -1);
+ g_return_val_if_fail (GTK_IS_NOTEBOOK (notebook), -1);
+
+ num = 0;
+ children = notebook->children;
+ while (children)
+ {
+ GtkNotebookPage *page;
+
+ page = children->data;
+ if (page->child == child)
+ return num;
+
+ children = children->next;
+ num++;
+ }
+
+ return -1;
+}
+
static void
gtk_notebook_real_remove (GtkNotebook *notebook,
GList *list,
}
static void
-gtk_notebook_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_notebook_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkNotebook *notebook;
- GtkNotebookPage *page;
GList *children;
g_return_if_fail (container != NULL);
g_return_if_fail (callback != NULL);
notebook = GTK_NOTEBOOK (container);
-
+
children = notebook->children;
while (children)
{
+ GtkNotebookPage *page;
+
page = children->data;
children = children->next;
(* callback) (page->child, callback_data);
+ if (include_internals)
+ {
+ if (page->tab_label)
+ (* callback) (page->tab_label, callback_data);
+ if (page->menu_label)
+ (* callback) (page->menu_label, callback_data);
+ }
}
}
void
gtk_notebook_set_show_tabs (GtkNotebook *notebook,
- gint show_tabs)
+ gboolean show_tabs)
{
GtkNotebookPage *page;
GList *children;
g_return_if_fail (notebook != NULL);
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
+ show_tabs = show_tabs != FALSE;
+
if (notebook->show_tabs == show_tabs)
return;
}
static void
-gtk_real_notebook_switch_page (GtkNotebook *notebook,
+gtk_notebook_real_switch_page (GtkNotebook *notebook,
GtkNotebookPage *page,
guint page_num)
{
g_list_find (notebook->children, notebook->cur_page);
gtk_notebook_pages_allocate (notebook, >K_WIDGET (notebook)->allocation);
-
+ gtk_notebook_expose_tabs (notebook);
+
if (GTK_WIDGET_MAPPED (notebook))
{
if (GTK_WIDGET_REALIZED (notebook->cur_page->child))
notebook = GTK_NOTEBOOK (container);
- if (!GTK_WIDGET_SENSITIVE (container) || !notebook->children)
+ if (!GTK_WIDGET_DRAWABLE (notebook) ||
+ !GTK_WIDGET_SENSITIVE (container) ||
+ !notebook->children)
return FALSE;
focus_child = container->focus_child;
if (!notebook->show_tabs)
{
- if (GTK_WIDGET_VISIBLE (notebook->cur_page->child))
+ if (GTK_WIDGET_DRAWABLE (notebook->cur_page->child) &&
+ GTK_WIDGET_SENSITIVE (notebook->cur_page->child))
{
if (GTK_IS_CONTAINER (notebook->cur_page->child))
{
- if (gtk_container_focus
- (GTK_CONTAINER (notebook->cur_page->child), direction))
+ if (gtk_container_focus (GTK_CONTAINER (notebook->cur_page->child), direction))
return TRUE;
}
else if (GTK_WIDGET_CAN_FOCUS (notebook->cur_page->child))
if (focus_child && old_page && focus_child == old_page->child &&
notebook->child_has_focus)
{
- if (GTK_WIDGET_VISIBLE (old_page->child))
+ if (GTK_WIDGET_DRAWABLE (old_page->child))
{
if (GTK_IS_CONTAINER (old_page->child) &&
!GTK_WIDGET_HAS_FOCUS (old_page->child))
case GTK_DIR_LEFT:
case GTK_DIR_UP:
if (!notebook->focus_tab)
- gtk_notebook_switch_focus_tab
- (notebook, g_list_last (notebook->children));
+ gtk_notebook_switch_focus_tab (notebook, g_list_last (notebook->children));
else
gtk_notebook_switch_focus_tab (notebook, notebook->focus_tab->prev);
if (return_val)
{
- if (!GTK_WIDGET_HAS_FOCUS (container) )
+ if (!GTK_WIDGET_HAS_FOCUS (container))
gtk_widget_grab_focus (GTK_WIDGET (container));
if (GTK_WIDGET_MAPPED (page->tab_label))
void gtk_notebook_remove_page (GtkNotebook *notebook,
gint page_num);
gint gtk_notebook_current_page (GtkNotebook *notebook);
+gint gtk_notebook_page_num (GtkNotebook *notebook,
+ GtkWidget *child);
void gtk_notebook_set_page (GtkNotebook *notebook,
gint page_num);
void gtk_notebook_next_page (GtkNotebook *notebook);
void gtk_notebook_set_tab_pos (GtkNotebook *notebook,
GtkPositionType pos);
void gtk_notebook_set_show_tabs (GtkNotebook *notebook,
- gint show_tabs);
+ gboolean show_tabs);
void gtk_notebook_set_show_border (GtkNotebook *notebook,
gint show_border);
void gtk_notebook_set_scrollable (GtkNotebook *notebook,
#include "gtkmenuitem.h"
#include "gtkoptionmenu.h"
#include "gtksignal.h"
+#include "gdk/gdkkeysyms.h"
#define CHILD_LEFT_SPACING 5
GdkEventExpose *event);
static gint gtk_option_menu_button_press (GtkWidget *widget,
GdkEventButton *event);
+static gint gtk_option_menu_key_press (GtkWidget *widget,
+ GdkEventKey *event);
static void gtk_option_menu_deactivate (GtkMenuShell *menu_shell,
GtkOptionMenu *option_menu);
static void gtk_option_menu_update_contents (GtkOptionMenu *option_menu);
static void gtk_option_menu_hide_all (GtkWidget *widget);
static GtkType gtk_option_menu_child_type (GtkContainer *container);
+
static GtkButtonClass *parent_class = NULL;
object_class->destroy = gtk_option_menu_destroy;
widget_class->draw = gtk_option_menu_draw;
- widget_class->draw_focus = NULL;
widget_class->size_request = gtk_option_menu_size_request;
widget_class->size_allocate = gtk_option_menu_size_allocate;
widget_class->expose_event = gtk_option_menu_expose;
widget_class->button_press_event = gtk_option_menu_button_press;
+ widget_class->key_press_event = gtk_option_menu_key_press;
widget_class->show_all = gtk_option_menu_show_all;
widget_class->hide_all = gtk_option_menu_hide_all;
static void
gtk_option_menu_init (GtkOptionMenu *option_menu)
{
- GTK_WIDGET_UNSET_FLAGS (option_menu, GTK_CAN_FOCUS);
+ GTK_WIDGET_SET_FLAGS (option_menu, GTK_CAN_FOCUS);
+ GTK_WIDGET_UNSET_FLAGS (option_menu, GTK_CAN_DEFAULT);
option_menu->menu = NULL;
option_menu->menu_item = NULL;
child = GTK_BIN (widget)->child;
if (child && gtk_widget_intersect (child, area, &child_area))
gtk_widget_draw (child, &child_area);
+ gtk_widget_draw_focus (widget);
}
}
gtk_widget_event (child, (GdkEvent*) &child_event);
#endif /* 0 */
+ gtk_widget_draw_focus (widget);
}
return FALSE;
g_return_val_if_fail (GTK_IS_OPTION_MENU (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
+ option_menu = GTK_OPTION_MENU (widget);
+
if ((event->type == GDK_BUTTON_PRESS) &&
(event->button == 1))
{
- option_menu = GTK_OPTION_MENU (widget);
gtk_option_menu_remove_contents (option_menu);
gtk_menu_popup (GTK_MENU (option_menu->menu), NULL, NULL,
gtk_option_menu_position, option_menu,
return FALSE;
}
+static gint
+gtk_option_menu_key_press (GtkWidget *widget,
+ GdkEventKey *event)
+{
+ GtkOptionMenu *option_menu;
+
+ g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_OPTION_MENU (widget), FALSE);
+ g_return_val_if_fail (event != NULL, FALSE);
+
+ option_menu = GTK_OPTION_MENU (widget);
+
+ switch (event->keyval)
+ {
+ case GDK_space:
+ gtk_option_menu_remove_contents (option_menu);
+ gtk_menu_popup (GTK_MENU (option_menu->menu), NULL, NULL,
+ gtk_option_menu_position, option_menu,
+ 0, event->time);
+ break;
+ }
+
+ return FALSE;
+}
+
static void
gtk_option_menu_deactivate (GtkMenuShell *menu_shell,
GtkOptionMenu *option_menu)
GtkWidget *child);
static void gtk_packer_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_packer_foreach (GtkContainer *container,
+static void gtk_packer_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_packer_set_arg (GtkObject *object,
container_class->add = gtk_packer_container_add;
container_class->remove = gtk_packer_remove;
- container_class->foreach = gtk_packer_foreach;
+ container_class->forall = gtk_packer_forall;
container_class->child_type = gtk_packer_child_type;
container_class->get_child_arg = gtk_packer_get_child_arg;
container_class->set_child_arg = gtk_packer_set_child_arg;
}
static void
-gtk_packer_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_packer_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkPacker *packer;
GtkPackerChild *child;
packer = GTK_PACKER (container);
- children = g_list_first(packer->children);
+ children = g_list_first (packer->children);
while (children != NULL)
{
child = children->data;
static void gtk_paned_unmap (GtkWidget *widget);
static void gtk_paned_unrealize (GtkWidget *widget);
static gint gtk_paned_expose (GtkWidget *widget,
- GdkEventExpose *event);
+ GdkEventExpose *event);
static void gtk_paned_add (GtkContainer *container,
- GtkWidget *widget);
+ GtkWidget *widget);
static void gtk_paned_remove (GtkContainer *container,
- GtkWidget *widget);
-static void gtk_paned_foreach (GtkContainer *container,
+ GtkWidget *widget);
+static void gtk_paned_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static GtkType gtk_paned_child_type (GtkContainer *container);
static GtkContainerClass *parent_class = NULL;
-guint
+GtkType
gtk_paned_get_type (void)
{
- static guint paned_type = 0;
-
+ static GtkType paned_type = 0;
+
if (!paned_type)
{
GtkTypeInfo paned_info =
/* reserved_2 */ NULL,
(GtkClassInitFunc) NULL,
};
-
- paned_type = gtk_type_unique (gtk_container_get_type (), &paned_info);
+
+ paned_type = gtk_type_unique (GTK_TYPE_CONTAINER, &paned_info);
}
-
+
return paned_type;
}
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
GtkContainerClass *container_class;
-
+
object_class = (GtkObjectClass*) class;
widget_class = (GtkWidgetClass*) class;
container_class = (GtkContainerClass*) class;
-
- parent_class = gtk_type_class (gtk_container_get_type ());
-
+
+ parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
+
widget_class->realize = gtk_paned_realize;
widget_class->map = gtk_paned_map;
widget_class->unmap = gtk_paned_unmap;
widget_class->unrealize = gtk_paned_unrealize;
widget_class->expose_event = gtk_paned_expose;
-
+
container_class->add = gtk_paned_add;
container_class->remove = gtk_paned_remove;
- container_class->foreach = gtk_paned_foreach;
+ container_class->forall = gtk_paned_forall;
container_class->child_type = gtk_paned_child_type;
}
gtk_paned_init (GtkPaned *paned)
{
GTK_WIDGET_UNSET_FLAGS (paned, GTK_NO_WINDOW);
-
+
paned->child1 = NULL;
paned->child2 = NULL;
paned->handle = NULL;
paned->xor_gc = NULL;
-
+
paned->handle_size = 10;
paned->gutter_size = 6;
paned->position_set = FALSE;
paned->in_drag = FALSE;
-
+
paned->handle_xpos = -1;
paned->handle_ypos = -1;
}
GtkPaned *paned;
GdkWindowAttr attributes;
gint attributes_mask;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PANED (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
paned = GTK_PANED (widget);
-
+
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
attributes.width = widget->allocation.width;
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.event_mask = gtk_widget_get_events (widget) | GDK_EXPOSURE_MASK;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, paned);
-
+
attributes.x = paned->handle_xpos;
attributes.y = paned->handle_ypos;
attributes.width = paned->handle_size;
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
attributes_mask |= GDK_WA_CURSOR;
-
+
paned->handle = gdk_window_new (widget->window,
&attributes, attributes_mask);
gdk_window_set_user_data (paned->handle, paned);
-
+
widget->style = gtk_style_attach (widget->style, widget->window);
-
+
gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
gtk_style_set_background (widget->style, paned->handle, GTK_STATE_NORMAL);
-
+
gdk_window_show (paned->handle);
}
-
+
static void
gtk_paned_map (GtkWidget *widget)
{
GtkPaned *paned;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PANED (widget));
-
+
GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
paned = GTK_PANED (widget);
-
+
gdk_window_show (widget->window);
-
+
if (paned->child1 &&
GTK_WIDGET_VISIBLE (paned->child1) &&
!GTK_WIDGET_MAPPED (paned->child1))
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PANED (widget));
-
+
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
-
+
gdk_window_hide (widget->window);
}
gtk_paned_unrealize (GtkWidget *widget)
{
GtkPaned *paned;
-
+
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PANED (widget));
-
+
paned = GTK_PANED (widget);
-
+
if (paned->xor_gc)
{
gdk_gc_destroy (paned->xor_gc);
paned->xor_gc = NULL;
}
-
+
if (paned->handle)
{
gdk_window_set_user_data (paned->handle, NULL);
gdk_cursor_destroy (paned->cursor);
paned->cursor = NULL;
}
-
+
if (GTK_WIDGET_CLASS (parent_class)->unrealize)
(* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
}
{
GtkPaned *paned;
GdkEventExpose child_event;
-
+
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_PANED (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
-
+
if (GTK_WIDGET_DRAWABLE (widget))
{
paned = GTK_PANED (widget);
-
+
/* An expose event for the handle */
if (event->window == paned->handle)
{
GTK_WIDGET_NO_WINDOW (paned->child1) &&
gtk_widget_intersect (paned->child1, &event->area, &child_event.area))
gtk_widget_event (paned->child1, (GdkEvent*) &child_event);
-
+
if (paned->child2 &&
GTK_WIDGET_NO_WINDOW (paned->child2) &&
gtk_widget_intersect (paned->child2, &event->area, &child_event.area))
gtk_widget_event (paned->child2, (GdkEvent*) &child_event);
-
+
/* redraw the groove if necessary */
if (gdk_rectangle_intersect (&paned->groove_rectangle,
&event->area,
GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
-
+
if (!paned->child1)
{
gtk_widget_set_parent (widget, GTK_WIDGET (paned));
-
+
if (GTK_WIDGET_VISIBLE (widget->parent))
{
if (GTK_WIDGET_REALIZED (widget->parent) &&
!GTK_WIDGET_MAPPED (widget))
gtk_widget_map (widget);
}
-
+
paned->child1 = widget;
-
+
if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (paned))
gtk_widget_queue_resize (widget);
}
GtkWidget *widget)
{
g_return_if_fail (widget != NULL);
-
+
if (!paned->child2)
{
gtk_widget_set_parent (widget, GTK_WIDGET (paned));
-
+
if (GTK_WIDGET_VISIBLE (widget->parent))
{
if (GTK_WIDGET_REALIZED (widget->parent) &&
!GTK_WIDGET_MAPPED (widget))
gtk_widget_map (widget);
}
-
+
paned->child2 = widget;
-
+
if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (paned))
gtk_widget_queue_resize (widget);
}
GtkWidget *widget)
{
GtkPaned *paned;
-
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_PANED (container));
g_return_if_fail (widget != NULL);
-
+
paned = GTK_PANED (container);
-
+
if (!paned->child1)
gtk_paned_add1 (GTK_PANED (container),widget);
else if (!paned->child2)
{
GtkPaned *paned;
gboolean was_visible;
-
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_PANED (container));
g_return_if_fail (widget != NULL);
-
+
paned = GTK_PANED (container);
was_visible = GTK_WIDGET_VISIBLE (widget);
if (paned->child1 == widget)
{
gtk_widget_unparent (widget);
-
+
paned->child1 = NULL;
-
+
if (was_visible && GTK_WIDGET_VISIBLE (container))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
else if (paned->child2 == widget)
{
gtk_widget_unparent (widget);
-
+
paned->child2 = NULL;
-
+
if (was_visible && GTK_WIDGET_VISIBLE (container))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
static void
-gtk_paned_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_paned_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkPaned *paned;
-
+
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_PANED (container));
g_return_if_fail (callback != NULL);
-
+
paned = GTK_PANED (container);
-
+
if (paned->child1)
(* callback) (paned->child1, callback_data);
if (paned->child2)
}
void
-gtk_paned_handle_size (GtkPaned *paned, guint16 size)
+gtk_paned_handle_size (GtkPaned *paned,
+ guint16 size)
{
gint x,y;
+
+ g_return_if_fail (paned != NULL);
+ g_return_if_fail (GTK_IS_PANED (paned));
if (paned->handle)
{
y + paned->handle_size / 2 - size / 2,
size, size);
}
-
paned->handle_size = size;
}
void
-gtk_paned_gutter_size (GtkPaned *paned, guint16 size)
+gtk_paned_gutter_size (GtkPaned *paned,
+ guint16 size)
{
- paned->gutter_size = size;
+ g_return_if_fail (paned != NULL);
+ g_return_if_fail (GTK_IS_PANED (paned));
+ paned->gutter_size = size;
+
if (GTK_WIDGET_VISIBLE (GTK_WIDGET (paned)))
gtk_widget_queue_resize (GTK_WIDGET (paned));
}
-
GtkWidget *widget);
static void gtk_scrolled_window_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_scrolled_window_foreach (GtkContainer *container,
+static void gtk_scrolled_window_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_scrolled_window_viewport_allocate (GtkWidget *widget,
container_class->add = gtk_scrolled_window_add;
container_class->remove = gtk_scrolled_window_remove;
- container_class->foreach = gtk_scrolled_window_foreach;
+ container_class->forall = gtk_scrolled_window_forall;
class->scrollbar_spacing = 5;
}
}
static void
-gtk_scrolled_window_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_scrolled_window_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkScrolledWindow *scrolled_window;
scrolled_window = GTK_SCROLLED_WINDOW (container);
- if (scrolled_window->viewport)
- (* callback) (scrolled_window->viewport, callback_data);
-
- (* callback) (scrolled_window->vscrollbar, callback_data);
- (* callback) (scrolled_window->hscrollbar, callback_data);
+ if (include_internals)
+ {
+ if (scrolled_window->viewport)
+ (* callback) (scrolled_window->viewport, callback_data);
+
+ (* callback) (scrolled_window->vscrollbar, callback_data);
+ (* callback) (scrolled_window->hscrollbar, callback_data);
+ }
+ else if (scrolled_window->viewport)
+ gtk_container_foreach (GTK_CONTAINER (scrolled_window->viewport), callback, callback_data);
}
static void
GtkWidget *widget);
static void gtk_table_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_table_foreach (GtkContainer *container,
+static void gtk_table_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_table_get_arg (GtkObject *object,
container_class->add = gtk_table_add;
container_class->remove = gtk_table_remove;
- container_class->foreach = gtk_table_foreach;
+ container_class->forall = gtk_table_forall;
container_class->child_type = gtk_table_child_type;
container_class->set_child_arg = gtk_table_set_child_arg;
container_class->get_child_arg = gtk_table_get_child_arg;
}
static void
-gtk_table_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_table_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkTable *table;
GtkTableChild *child;
GtkWidget *widget);
static void gtk_toolbar_remove (GtkContainer *container,
GtkWidget *widget);
-static void gtk_toolbar_foreach (GtkContainer *container,
+static void gtk_toolbar_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
static void gtk_real_toolbar_orientation_changed (GtkToolbar *toolbar,
container_class->add = gtk_toolbar_add;
container_class->remove = gtk_toolbar_remove;
- container_class->foreach = gtk_toolbar_foreach;
+ container_class->forall = gtk_toolbar_forall;
container_class->focus = NULL;
class->orientation_changed = gtk_real_toolbar_orientation_changed;
}
static void
-gtk_toolbar_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_toolbar_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkToolbar *toolbar;
GList *children;
g_return_val_if_fail (toolbar != NULL, NULL);
g_return_val_if_fail (GTK_IS_TOOLBAR (toolbar), NULL);
- g_return_val_if_fail ((type != GTK_TOOLBAR_CHILD_WIDGET) || (widget != NULL), NULL);
+ if (type == GTK_TOOLBAR_CHILD_WIDGET)
+ {
+ g_return_val_if_fail (widget != NULL, NULL);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
+ }
+ else
+ g_return_val_if_fail (widget == NULL, NULL);
child = g_new (GtkToolbarChild, 1);
child->type = type;
gtk_toolbar_set_orientation (GtkToolbar *toolbar,
GtkOrientation orientation)
{
+ g_return_if_fail (toolbar != NULL);
+ g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
+
gtk_signal_emit (GTK_OBJECT (toolbar), toolbar_signals[ORIENTATION_CHANGED], orientation);
}
gtk_toolbar_set_style (GtkToolbar *toolbar,
GtkToolbarStyle style)
{
+ g_return_if_fail (toolbar != NULL);
+ g_return_if_fail (GTK_IS_TOOLBAR (toolbar));
+
gtk_signal_emit (GTK_OBJECT (toolbar), toolbar_signals[STYLE_CHANGED], style);
}
}
GtkReliefStyle
-gtk_toolbar_get_button_relief (GtkToolbar *toolbar)
+gtk_toolbar_get_button_relief (GtkToolbar *toolbar)
{
g_return_val_if_fail (toolbar != NULL, GTK_RELIEF_NORMAL);
g_return_val_if_fail (GTK_IS_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
static void gtk_tooltips_set_active_widget (GtkTooltips *tooltips,
GtkWidget *widget);
static gint gtk_tooltips_timeout (gpointer data);
-static void gtk_tooltips_create_window (GtkTooltips *tooltips);
static void gtk_tooltips_draw_tips (GtkTooltips *tooltips);
static GtkDataClass *parent_class;
static const gchar *tooltips_data_key = "_GtkTooltipsData";
-guint
+GtkType
gtk_tooltips_get_type (void)
{
- static guint tooltips_type = 0;
+ static GtkType tooltips_type = 0;
if (!tooltips_type)
{
(GtkClassInitFunc) NULL,
};
- tooltips_type = gtk_type_unique (gtk_data_get_type (), &tooltips_info);
+ tooltips_type = gtk_type_unique (GTK_TYPE_DATA, &tooltips_info);
}
return tooltips_type;
GtkObjectClass *object_class;
object_class = (GtkObjectClass*) class;
- parent_class = gtk_type_class (gtk_data_get_type ());
+ parent_class = gtk_type_class (GTK_TYPE_DATA);
object_class->destroy = gtk_tooltips_destroy;
}
GtkTooltips *
gtk_tooltips_new (void)
{
- return gtk_type_new (gtk_tooltips_get_type ());
+ return gtk_type_new (GTK_TYPE_TOOLTIPS);
}
static void
}
}
- if (tooltips->tip_window != NULL)
- {
- gtk_widget_destroy (tooltips->tip_window);
- gtk_widget_unref (tooltips->tip_window);
- tooltips->tip_window = NULL;
- }
+ if (tooltips->tip_window)
+ gtk_widget_destroy (tooltips->tip_window);
if (tooltips->gc != NULL)
{
}
}
-static void
-gtk_tooltips_create_window (GtkTooltips *tooltips)
+void
+gtk_tooltips_force_window (GtkTooltips *tooltips)
{
- tooltips->tip_window = gtk_window_new (GTK_WINDOW_POPUP);
- gtk_widget_ref (tooltips->tip_window);
- gtk_window_set_policy (GTK_WINDOW (tooltips->tip_window), FALSE, FALSE, TRUE);
- gtk_widget_realize (tooltips->tip_window);
+ g_return_if_fail (tooltips != NULL);
+ g_return_if_fail (GTK_IS_TOOLTIPS (tooltips));
+
+ if (!tooltips->tip_window)
+ {
+ tooltips->tip_window = gtk_window_new (GTK_WINDOW_POPUP);
+ gtk_window_set_policy (GTK_WINDOW (tooltips->tip_window), FALSE, FALSE, TRUE);
+ gtk_widget_realize (tooltips->tip_window);
+ gtk_signal_connect (GTK_OBJECT (tooltips->tip_window),
+ "destroy",
+ gtk_widget_destroyed,
+ &tooltips->tip_window);
+ }
}
static void
gint i, row_width, window_width = 0;
size_t len;
- if (tooltips->tip_window == NULL)
- gtk_tooltips_create_window (tooltips);
+ if (!tooltips->tip_window)
+ gtk_tooltips_force_window (tooltips);
g_list_foreach (data->row, gtk_tooltips_free_string, 0);
if (data->row)
GList *el;
if (!tooltips->tip_window)
- gtk_tooltips_create_window (tooltips);
+ gtk_tooltips_force_window (tooltips);
else if (GTK_WIDGET_VISIBLE (tooltips->tip_window))
gtk_widget_hide (tooltips->tip_window);
#ifdef __cplusplus
extern "C" {
+#pragma }
#endif /* __cplusplus */
-#define GTK_TOOLTIPS(obj) GTK_CHECK_CAST (obj, gtk_tooltips_get_type (), GtkTooltips)
-#define GTK_TOOLTIPS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_tooltips_get_type (), GtkTooltipsClass)
-#define GTK_IS_TOOLTIPS(obj) GTK_CHECK_TYPE (obj, gtk_tooltips_get_type ())
+#define GTK_TYPE_TOOLTIPS (gtk_tooltips_get_type ())
+#define GTK_TOOLTIPS(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_TOOLTIPS, GtkTooltips))
+#define GTK_TOOLTIPS_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GTK_TYPE_TOOLTIPS, GtkTooltipsClass))
+#define GTK_IS_TOOLTIPS(obj) (GTK_CHECK_TYPE ((obj), GTK_TYPE_TOOLTIPS))
+#define GTK_IS_TOOLTIPS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TOOLTIPS))
typedef struct _GtkTooltips GtkTooltips;
typedef struct _GtkTooltipsClass GtkTooltipsClass;
GtkDataClass parent_class;
};
-GtkType gtk_tooltips_get_type (void);
-GtkTooltips* gtk_tooltips_new (void);
-
-void gtk_tooltips_enable (GtkTooltips *tooltips);
-void gtk_tooltips_disable (GtkTooltips *tooltips);
-void gtk_tooltips_set_delay (GtkTooltips *tooltips,
- guint delay);
-void gtk_tooltips_set_tip (GtkTooltips *tooltips,
- GtkWidget *widget,
- const gchar *tip_text,
- const gchar *tip_private);
-void gtk_tooltips_set_colors (GtkTooltips *tooltips,
- GdkColor *background,
- GdkColor *foreground);
-GtkTooltipsData* gtk_tooltips_data_get (GtkWidget *widget);
+GtkType gtk_tooltips_get_type (void);
+GtkTooltips* gtk_tooltips_new (void);
+
+void gtk_tooltips_enable (GtkTooltips *tooltips);
+void gtk_tooltips_disable (GtkTooltips *tooltips);
+void gtk_tooltips_set_delay (GtkTooltips *tooltips,
+ guint delay);
+void gtk_tooltips_set_tip (GtkTooltips *tooltips,
+ GtkWidget *widget,
+ const gchar *tip_text,
+ const gchar *tip_private);
+void gtk_tooltips_set_colors (GtkTooltips *tooltips,
+ GdkColor *background,
+ GdkColor *foreground);
+GtkTooltipsData* gtk_tooltips_data_get (GtkWidget *widget);
+void gtk_tooltips_force_window (GtkTooltips *tooltips);
GtkAllocation *allocation);
static void gtk_tree_add (GtkContainer *container,
GtkWidget *widget);
-static void gtk_tree_foreach (GtkContainer *container,
+static void gtk_tree_forall (GtkContainer *container,
+ gboolean include_internals,
GtkCallback callback,
gpointer callback_data);
container_class->add = gtk_tree_add;
container_class->remove =
(void (*)(GtkContainer *, GtkWidget *)) gtk_tree_remove_item;
- container_class->foreach = gtk_tree_foreach;
+ container_class->forall = gtk_tree_forall;
container_class->child_type = gtk_tree_child_type;
class->selection_changed = NULL;
}
static void
-gtk_tree_foreach (GtkContainer *container,
- GtkCallback callback,
- gpointer callback_data)
+gtk_tree_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
{
GtkTree *tree;
GtkWidget *child;
children = children->next;
(* callback) (child, callback_data);
-
- if(GTK_TREE_ITEM(child)->subtree)
- (* callback)(GTK_TREE_ITEM(child)->subtree, callback_data);
}
}
GdkEventFocus *event);
static gint gtk_tree_item_focus_out (GtkWidget *widget,
GdkEventFocus *event);
+static void gtk_tree_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
+
static void gtk_real_tree_item_select (GtkItem *item);
static void gtk_real_tree_item_deselect (GtkItem *item);
static void gtk_real_tree_item_toggle (GtkItem *item);
static void gtk_tree_item_remove_pixmaps (GtkTreeItem *tree_item);
static GtkItemClass *parent_class = NULL;
-static GtkContainerClass *container_class = NULL;
static guint tree_item_signals[LAST_SIGNAL] = { 0 };
GtkType
{
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
+ GtkContainerClass *container_class;
GtkItemClass *item_class;
object_class = (GtkObjectClass*) class;
widget_class->map = gtk_tree_item_map;
widget_class->unmap = gtk_tree_item_unmap;
+ container_class->forall = gtk_tree_item_forall;
+
item_class->select = gtk_real_tree_item_select;
item_class->deselect = gtk_real_tree_item_deselect;
item_class->toggle = gtk_real_tree_item_toggle;
class->expand = gtk_real_tree_item_expand;
class->collapse = gtk_real_tree_item_collapse;
-
- container_class = (GtkContainerClass*) parent_class;
}
/* callback for event box mouse event */
/* show subtree button */
if (tree_item->pixmaps_box)
- gtk_widget_show(tree_item->pixmaps_box);
+ gtk_widget_show (tree_item->pixmaps_box);
/* set parent widget */
gtk_widget_set_parent(subtree, GTK_WIDGET(tree_item)->parent);
gtk_widget_map (GTK_WIDGET(subtree));
}
- if(tree_item->expanded)
+ if (tree_item->expanded)
gtk_widget_show(subtree);
else
gtk_widget_hide(subtree);
requisition->width += item->pixmaps_box->requisition.width + DEFAULT_DELTA +
GTK_TREE(widget->parent)->current_indent;
- requisition->height += MAX(bin->child->requisition.height,
- item->pixmaps_box->requisition.height);
+ requisition->height += MAX (bin->child->requisition.height,
+ item->pixmaps_box->requisition.height);
}
}
}
static void
-gtk_tree_item_draw_lines(GtkWidget *widget)
+gtk_tree_item_draw_lines (GtkWidget *widget)
{
GtkTreeItem* item;
GtkTree* tree;
/* draw vertical line */
lx1 = item->pixmaps_box->allocation.width;
- lx1 = lx2 = ( lx1 / 2 ) + ( lx1 % 2 ) +
- GTK_CONTAINER(widget)->border_width + 1 + tree->current_indent;
+ lx1 = lx2 = ((lx1 / 2) + (lx1 % 2) +
+ GTK_CONTAINER (widget)->border_width + 1 + tree->current_indent);
ly1 = 0;
ly2 = widget->allocation.height;
- if(g_list_last(tree->children)->data == (gpointer)widget)
+ if (g_list_last (tree->children)->data == widget)
ly2 = (ly2 / 2) + (ly2 % 2);
- if(tree != tree->root_tree)
- gdk_draw_line(widget->window, widget->style->black_gc,
- lx1, ly1, lx2, ly2);
+ if (tree != tree->root_tree)
+ gdk_draw_line (widget->window, widget->style->black_gc, lx1, ly1, lx2, ly2);
/* draw vertical line for subtree connecting */
if(g_list_last(tree->children)->data != (gpointer)widget)
lx2 += DEFAULT_DELTA;
- if(item->subtree && item->expanded)
- gdk_draw_line(widget->window, widget->style->black_gc,
- lx2, ly2, lx2, widget->allocation.height);
+ if (item->subtree && item->expanded)
+ gdk_draw_line (widget->window, widget->style->black_gc,
+ lx2, ly2, lx2, widget->allocation.height);
/* draw horizontal line */
ly1 = ly2;
lx2 += 2;
- gdk_draw_line(widget->window, widget->style->black_gc,
- lx1, ly1, lx2, ly2);
+ gdk_draw_line (widget->window, widget->style->black_gc,
+ lx1, ly1, lx2, ly2);
lx2 -= DEFAULT_DELTA+2;
ly1 = 0;
ly2 = widget->allocation.height;
- if(tree != tree->root_tree)
+ if (tree != tree->root_tree)
{
- item = GTK_TREE_ITEM(tree->tree_owner);
- tree = GTK_TREE(GTK_WIDGET(tree)->parent);
- while(tree != tree->root_tree) {
- lx1 = lx2 -= tree->indent_value;
-
- if(g_list_last(tree->children)->data != (gpointer)item)
- gdk_draw_line(widget->window, widget->style->black_gc,
- lx1, ly1, lx2, ly2);
- item = GTK_TREE_ITEM(tree->tree_owner);
- tree = GTK_TREE(GTK_WIDGET(tree)->parent);
- }
+ item = GTK_TREE_ITEM (tree->tree_owner);
+ tree = GTK_TREE (GTK_WIDGET (tree)->parent);
+ while (tree != tree->root_tree)
+ {
+ lx1 = lx2 -= tree->indent_value;
+
+ if (g_list_last (tree->children)->data != item)
+ gdk_draw_line (widget->window, widget->style->black_gc, lx1, ly1, lx2, ly2);
+ item = GTK_TREE_ITEM (tree->tree_owner);
+ tree = GTK_TREE (GTK_WIDGET (tree)->parent);
+ }
}
}
tree_item = GTK_TREE_ITEM(widget);
/* draw left size of tree item */
- item_area.x = 0; item_area.y = 0;
- item_area.width = tree_item->pixmaps_box->allocation.width+DEFAULT_DELTA +
- (GTK_TREE(widget->parent)->current_indent + 2);
+ item_area.x = 0;
+ item_area.y = 0;
+ item_area.width = (tree_item->pixmaps_box->allocation.width + DEFAULT_DELTA +
+ GTK_TREE (widget->parent)->current_indent + 2);
item_area.height = widget->allocation.height;
- if(gdk_rectangle_intersect(&item_area, area, &child_area)) {
-
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
- gtk_style_set_background (widget->style, widget->window,
- GTK_STATE_INSENSITIVE);
- else if(GTK_TREE(widget->parent)->view_mode == GTK_TREE_VIEW_LINE &&
- widget->state == GTK_STATE_SELECTED)
- gtk_style_set_background (widget->style, widget->window, widget->state);
- else
- gdk_window_set_background (widget->window,
- &widget->style->base[GTK_STATE_NORMAL]);
-
- gdk_window_clear_area (widget->window,
- child_area.x, child_area.y,
- child_area.width, child_area.height);
-
-/* gtk_tree_item_draw_lines(widget); */
-
- if (tree_item->pixmaps_box &&
- GTK_WIDGET_VISIBLE(tree_item->pixmaps_box) &&
- gtk_widget_intersect (tree_item->pixmaps_box, area, &child_area))
- gtk_widget_draw (tree_item->pixmaps_box, &child_area);
- }
-
+ if (gdk_rectangle_intersect (&item_area, area, &child_area))
+ {
+ if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ gtk_style_set_background (widget->style, widget->window,
+ GTK_STATE_INSENSITIVE);
+ else if(GTK_TREE(widget->parent)->view_mode == GTK_TREE_VIEW_LINE &&
+ widget->state == GTK_STATE_SELECTED)
+ gtk_style_set_background (widget->style, widget->window, widget->state);
+ else
+ gdk_window_set_background (widget->window,
+ &widget->style->base[GTK_STATE_NORMAL]);
+
+ gdk_window_clear_area (widget->window,
+ child_area.x, child_area.y,
+ child_area.width, child_area.height);
+
+ /* gtk_tree_item_draw_lines(widget); */
+
+ if (tree_item->pixmaps_box &&
+ GTK_WIDGET_VISIBLE(tree_item->pixmaps_box) &&
+ gtk_widget_intersect (tree_item->pixmaps_box, area, &child_area))
+ gtk_widget_draw (tree_item->pixmaps_box, &child_area);
+ }
+
/* draw right side */
- if(gtk_widget_intersect (bin->child, area, &child_area)) {
-
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
- gtk_style_set_background (widget->style, widget->window,
- GTK_STATE_INSENSITIVE);
- else if (widget->state == GTK_STATE_NORMAL)
- gdk_window_set_background(widget->window, &widget->style->base[GTK_STATE_NORMAL]);
- else
- gtk_style_set_background (widget->style, widget->window, widget->state);
-
+ if (gtk_widget_intersect (bin->child, area, &child_area))
+ {
+ if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ gtk_style_set_background (widget->style, widget->window,
+ GTK_STATE_INSENSITIVE);
+ else if (widget->state == GTK_STATE_NORMAL)
+ gdk_window_set_background (widget->window, &widget->style->base[GTK_STATE_NORMAL]);
+ else
+ gtk_style_set_background (widget->style, widget->window, widget->state);
+
gdk_window_clear_area (widget->window, child_area.x, child_area.y,
child_area.width+1, child_area.height);
-
+
if (bin->child &&
GTK_WIDGET_VISIBLE(bin->child) &&
gtk_widget_intersect (bin->child, area, &child_area))
gtk_widget_draw (bin->child, &child_area);
}
-
+
gtk_widget_draw_focus (widget);
}
}
dx = 0;
- if(GTK_TREE(widget->parent)->view_mode == GTK_TREE_VIEW_ITEM)
- dx = GTK_TREE_ITEM(widget)->pixmaps_box->allocation.width + DEFAULT_DELTA +
- GTK_TREE(widget->parent)->current_indent+1;
-
+ if (GTK_TREE(widget->parent)->view_mode == GTK_TREE_VIEW_ITEM)
+ dx = (GTK_TREE_ITEM(widget)->pixmaps_box->allocation.width + DEFAULT_DELTA +
+ GTK_TREE(widget->parent)->current_indent + 1);
+
gdk_draw_rectangle (widget->window, gc, FALSE, dx, 0,
widget->allocation.width - 1 - dx,
widget->allocation.height - 1);
static void
gtk_real_tree_item_select (GtkItem *item)
{
+ GtkTreeItem *tree_item;
+ GtkWidget *widget;
+
g_return_if_fail (item != NULL);
g_return_if_fail (GTK_IS_TREE_ITEM (item));
- if (GTK_WIDGET (item)->state == GTK_STATE_SELECTED
- || !GTK_WIDGET_IS_SENSITIVE(item))
- return;
-
- if(GTK_TREE(GTK_WIDGET(item)->parent)->view_mode == GTK_TREE_VIEW_LINE)
- gtk_widget_set_state (GTK_TREE_ITEM (item)->pixmaps_box, GTK_STATE_SELECTED);
+ tree_item = GTK_TREE_ITEM (item);
+ widget = GTK_WIDGET (item);
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
- gtk_widget_queue_draw (GTK_WIDGET (item));
+ if (!widget->parent || GTK_TREE (widget->parent)->view_mode == GTK_TREE_VIEW_LINE)
+ gtk_widget_set_state (GTK_TREE_ITEM (item)->pixmaps_box, GTK_STATE_SELECTED);
}
static void
gtk_real_tree_item_deselect (GtkItem *item)
{
+ GtkTreeItem *tree_item;
+ GtkWidget *widget;
+
g_return_if_fail (item != NULL);
g_return_if_fail (GTK_IS_TREE_ITEM (item));
- if (GTK_WIDGET (item)->state == GTK_STATE_NORMAL)
- return;
+ tree_item = GTK_TREE_ITEM (item);
+ widget = GTK_WIDGET (item);
- if(GTK_WIDGET_MAPPED(GTK_WIDGET (item)))
- {
- gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_NORMAL);
-
- if(GTK_TREE(GTK_WIDGET(item)->parent)->view_mode == GTK_TREE_VIEW_LINE)
- gtk_widget_set_state (GTK_TREE_ITEM (item)->pixmaps_box, GTK_STATE_NORMAL);
+ gtk_widget_set_state (widget, GTK_STATE_NORMAL);
- gtk_widget_queue_draw (GTK_WIDGET (item));
- }
+ if (!widget->parent || GTK_TREE (widget->parent)->view_mode == GTK_TREE_VIEW_LINE)
+ gtk_widget_set_state (tree_item->pixmaps_box, GTK_STATE_NORMAL);
}
static void
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_NORMAL);
else
gtk_widget_set_state (GTK_WIDGET (item), GTK_STATE_SELECTED);
- gtk_widget_queue_draw (GTK_WIDGET (item));
}
}
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_TREE_ITEM (widget));
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
bin = GTK_BIN (widget);
item = GTK_TREE_ITEM(widget);
- if (!GTK_WIDGET_NO_WINDOW (widget))
- gdk_window_show (widget->window);
- else
- gtk_widget_queue_draw (widget);
+ GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+
+ gdk_window_show (widget->window);
if(item->pixmaps_box &&
GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
bin = GTK_BIN (widget);
item = GTK_TREE_ITEM(widget);
- if (GTK_WIDGET_NO_WINDOW (widget))
- gdk_window_clear_area (widget->window,
- widget->allocation.x,
- widget->allocation.y,
- widget->allocation.width,
- widget->allocation.height);
- else
- gdk_window_hide (widget->window);
+ gdk_window_hide (widget->window);
if(item->pixmaps_box &&
GTK_WIDGET_VISIBLE (item->pixmaps_box) &&
GTK_WIDGET_MAPPED (bin->child))
gtk_widget_unmap (bin->child);
}
+
+static void
+gtk_tree_item_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ GtkBin *bin;
+ GtkTreeItem *tree_item;
+
+ g_return_if_fail (container != NULL);
+ g_return_if_fail (GTK_IS_TREE_ITEM (container));
+ g_return_if_fail (callback != NULL);
+
+ bin = GTK_BIN (container);
+ tree_item = GTK_TREE_ITEM (container);
+
+ if (bin->child)
+ (* callback) (bin->child, callback_data);
+ if (include_internals && tree_item->subtree)
+ (* callback) (tree_item->subtree, callback_data);
+}
{ GTK_HAS_DEFAULT, "GTK_HAS_DEFAULT", "has-default" },
{ GTK_HAS_GRAB, "GTK_HAS_GRAB", "has-grab" },
{ GTK_RC_STYLE, "GTK_RC_STYLE", "rc-style" },
+ { GTK_COMPOSITE_CHILD, "GTK_COMPOSITE_CHILD", "composite-child" },
{ GTK_BASIC, "GTK_BASIC", "basic" },
{ 0, NULL, NULL }
};
ARG_HAS_FOCUS,
ARG_CAN_DEFAULT,
ARG_HAS_DEFAULT,
+ ARG_COMPOSITE_CHILD,
ARG_STYLE,
ARG_EVENTS,
ARG_EXTENSION_EVENTS
GtkStateType state;
guint state_restoration : 1;
guint parent_sensitive : 1;
+ guint use_forall : 1;
};
static void gtk_widget_class_init (GtkWidgetClass *klass);
static GSList *colormap_stack = NULL;
static GSList *visual_stack = NULL;
static GSList *style_stack = NULL;
-
+static guint composite_child_stack = 0;
static GSList *gtk_widget_redraw_queue = NULL;
static const gchar *aux_info_key = "gtk-aux-info";
gtk_object_add_arg_type ("GtkWidget::has_focus", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_FOCUS);
gtk_object_add_arg_type ("GtkWidget::can_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_CAN_DEFAULT);
gtk_object_add_arg_type ("GtkWidget::has_default", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_HAS_DEFAULT);
+ gtk_object_add_arg_type ("GtkWidget::composite_child", GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_COMPOSITE_CHILD);
gtk_object_add_arg_type ("GtkWidget::style", GTK_TYPE_STYLE, GTK_ARG_READWRITE, ARG_STYLE);
gtk_object_add_arg_type ("GtkWidget::events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EVENTS);
gtk_object_add_arg_type ("GtkWidget::extension_events", GTK_TYPE_GDK_EVENT_MASK, GTK_ARG_READWRITE, ARG_EXTENSION_EVENTS);
klass->activate_signal = 0;
klass->show = gtk_widget_real_show;
+ klass->show_all = gtk_widget_show;
klass->hide = gtk_widget_real_hide;
- klass->show_all = gtk_widget_real_show;
- klass->hide_all = gtk_widget_real_hide;
+ klass->hide_all = gtk_widget_hide;
klass->map = gtk_widget_real_map;
klass->unmap = gtk_widget_real_unmap;
klass->realize = gtk_widget_real_realize;
if (GTK_VALUE_BOOL (*arg))
gtk_widget_grab_default (widget);
break;
+ case ARG_COMPOSITE_CHILD:
+ if (GTK_VALUE_BOOL(*arg))
+ GTK_WIDGET_SET_FLAGS (widget, GTK_COMPOSITE_CHILD);
+ else
+ GTK_WIDGET_UNSET_FLAGS (widget, GTK_COMPOSITE_CHILD);
+ break;
case ARG_STYLE:
gtk_widget_set_style (widget, (GtkStyle*) GTK_VALUE_BOXED (*arg));
break;
case ARG_HAS_DEFAULT:
GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_HAS_DEFAULT (widget) != FALSE);
break;
+ case ARG_COMPOSITE_CHILD:
+ GTK_VALUE_BOOL (*arg) = (GTK_WIDGET_COMPOSITE_CHILD (widget) != FALSE);
+ break;
case ARG_STYLE:
GTK_VALUE_BOXED (*arg) = (gpointer) gtk_widget_get_style (widget);
break;
widget->window = NULL;
widget->parent = NULL;
- GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE | GTK_PARENT_SENSITIVE);
+ GTK_WIDGET_SET_FLAGS (widget,
+ GTK_SENSITIVE |
+ GTK_PARENT_SENSITIVE |
+ (composite_child_stack ? GTK_COMPOSITE_CHILD : 0));
widget->style = gtk_widget_peek_style ();
gtk_style_ref (widget->style);
return TRUE;
}
-/*****************************************
- * gtk_widget_show_all:
- *
- * Shows the widget and all children.
- *
- * Container classes overwrite
- * show_all and hide_all to call
- * show_all (hide_all) on both themselves
- * and on their child widgets.
- *
- * arguments:
- *
- * results:
- *****************************************/
-
void
gtk_widget_show_all (GtkWidget *widget)
{
- GtkWidgetClass *widget_class;
-
+ GtkWidgetClass *class;
+
g_return_if_fail (widget != NULL);
-
- /* show_all shouldn't be invoked through a signal,
- because in this case it would be quite slow - there would
- be a show and show_all signal emitted for every child widget.
- */
- widget_class = GTK_WIDGET_CLASS(GTK_OBJECT(widget)->klass);
- widget_class->show_all (widget);
-}
+ g_return_if_fail (GTK_IS_WIDGET (widget));
-/*****************************************
- * gtk_widget_hide_all:
- *
- * Hides the widget and all children.
- * See gtk_widget_show_all.
- *
- * arguments:
- *
- * results:
- *****************************************/
+ class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
+
+ if (class->show_all)
+ class->show_all (widget);
+}
void
gtk_widget_hide_all (GtkWidget *widget)
{
+ GtkWidgetClass *class;
+
g_return_if_fail (widget != NULL);
- g_assert (widget->parent);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ class = GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass);
- GTK_WIDGET_CLASS (GTK_OBJECT (widget)->klass)->hide_all (widget);
+ if (class->hide_all)
+ class->hide_all (widget);
}
/*****************************************
g_return_if_fail (widget != NULL);
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- gtk_widget_draw_children_recurse,
- NULL);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_widget_draw_children_recurse,
+ NULL);
}
/*****************************************
gdk_window_ref (widget->window);
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- gtk_widget_reparent_container_child,
- client_data);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_widget_reparent_container_child,
+ client_data);
}
else
gdk_window_reparent (widget->window,
if (GTK_WIDGET_NO_WINDOW (widget))
{
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- gtk_widget_reparent_container_child,
- gtk_widget_get_parent_window (widget));
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_widget_reparent_container_child,
+ gtk_widget_get_parent_window (widget));
else
{
GdkWindow *parent_window;
data.state = state;
data.state_restoration = FALSE;
+ data.use_forall = FALSE;
if (widget->parent)
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
else
data.state = GTK_WIDGET_STATE (widget);
}
data.state_restoration = TRUE;
+ data.use_forall = TRUE;
if (widget->parent)
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
data.state = GTK_WIDGET_STATE (widget);
data.state_restoration = FALSE;
data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (parent) != FALSE);
+ data.use_forall = GTK_WIDGET_IS_SENSITIVE (parent) != GTK_WIDGET_IS_SENSITIVE (widget);
gtk_widget_propagate_state (widget, &data);
gtk_widget_set_rc_style (widget);
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- gtk_widget_set_style_recurse,
- NULL);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ gtk_widget_set_style_recurse,
+ NULL);
}
void
visual_stack = g_slist_prepend (visual_stack, visual);
}
+void
+gtk_widget_push_composite (void)
+{
+ composite_child_stack++;
+}
+
+void
+gtk_widget_pop_composite (void)
+{
+ if (composite_child_stack)
+ composite_child_stack--;
+}
+
/*****************************************
* gtk_widget_pop_colormap:
*
/* Unrealize afterwards to improve visual effect */
if (GTK_IS_CONTAINER (widget))
- gtk_container_foreach (GTK_CONTAINER (widget),
- (GtkCallback) gtk_widget_unrealize,
- NULL);
+ gtk_container_forall (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_unrealize,
+ NULL);
}
/*****************************************
return gtk_widget_get_default_visual ();
}
-/*************************************************************
- * gtk_widget_propagate_state:
- * Propagate a change in the widgets state down the tree
- *
- * arguments:
- * widget
- * GtkStateData: state
- * parent_sensitive
- *
- * results:
- *************************************************************/
-
static void
gtk_widget_propagate_state (GtkWidget *widget,
GtkStateData *data)
{
data->parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget) != FALSE);
data->state = GTK_WIDGET_STATE (widget);
- gtk_container_foreach (GTK_CONTAINER (widget),
- (GtkCallback) gtk_widget_propagate_state,
- data);
+ if (data->use_forall)
+ gtk_container_forall (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_propagate_state,
+ data);
+ else
+ gtk_container_foreach (GTK_CONTAINER (widget),
+ (GtkCallback) gtk_widget_propagate_state,
+ data);
}
gtk_widget_unref (widget);
}
GTK_HAS_DEFAULT = 1 << 14,
GTK_HAS_GRAB = 1 << 15,
GTK_RC_STYLE = 1 << 16,
- GTK_BASIC = 1 << 17
+ GTK_COMPOSITE_CHILD = 1 << 17,
+ GTK_BASIC = 1 << 18
} GtkWidgetFlags;
/* Macro for casting a pointer to a GtkWidget or GtkWidgetClass pointer.
#define GTK_WIDGET_CAN_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_CAN_DEFAULT) != 0)
#define GTK_WIDGET_HAS_DEFAULT(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_DEFAULT) != 0)
#define GTK_WIDGET_HAS_GRAB(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_HAS_GRAB) != 0)
-#define GTK_WIDGET_BASIC(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_BASIC) != 0)
#define GTK_WIDGET_RC_STYLE(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_RC_STYLE) != 0)
+#define GTK_WIDGET_COMPOSITE_CHILD(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_COMPOSITE_CHILD) != 0)
+#define GTK_WIDGET_BASIC(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_BASIC) != 0)
/* Macros for setting and clearing widget flags.
*/
/* basics */
void (* show) (GtkWidget *widget);
+ void (* show_all) (GtkWidget *widget);
void (* hide) (GtkWidget *widget);
- void (* show_all) (GtkWidget *widget);
- void (* hide_all) (GtkWidget *widget);
+ void (* hide_all) (GtkWidget *widget);
void (* map) (GtkWidget *widget);
void (* unmap) (GtkWidget *widget);
void (* realize) (GtkWidget *widget);
* This will override the values that got set by the
* gtk_widget_set_default_* () functions.
*/
-void gtk_widget_push_style (GtkStyle *style);
-void gtk_widget_push_colormap (GdkColormap *cmap);
-void gtk_widget_push_visual (GdkVisual *visual);
-void gtk_widget_pop_style (void);
-void gtk_widget_pop_colormap (void);
-void gtk_widget_pop_visual (void);
+void gtk_widget_push_style (GtkStyle *style);
+void gtk_widget_push_colormap (GdkColormap *cmap);
+void gtk_widget_push_visual (GdkVisual *visual);
+void gtk_widget_push_composite_flag (void);
+void gtk_widget_pop_composite_flag (void);
+void gtk_widget_pop_style (void);
+void gtk_widget_pop_colormap (void);
+void gtk_widget_pop_visual (void);
/* Set certain default values to be used at widget creation time.
*/
projects / gtk4.git / commitdiff